home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 August: Tool Chest / Dev.CD Aug 00 TC Disk 2.toast / pc / sample code / human interface toolbox / handyscrollingsample / handywindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-23  |  40.1 KB  |  1,096 lines
  1. /*
  2.     File: HandyWindow.c
  3.     
  4.     Description:
  5.         HandyWindow.c implements the routines used for drawing the windows
  6.     displayed by this application.
  7.  
  8.     Copyright:
  9.         © Copyright 2000 Apple Computer, Inc. All rights reserved.
  10.     
  11.     Disclaimer:
  12.         IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
  13.         ("Apple") in consideration of your agreement to the following terms, and your
  14.         use, installation, modification or redistribution of this Apple software
  15.         constitutes acceptance of these terms.  If you do not agree with these terms,
  16.         please do not use, install, modify or redistribute this Apple software.
  17.  
  18.         In consideration of your agreement to abide by the following terms, and subject
  19.         to these terms, Apple grants you a personal, non-exclusive license, under Apple’s
  20.         copyrights in this original Apple software (the "Apple Software"), to use,
  21.         reproduce, modify and redistribute the Apple Software, with or without
  22.         modifications, in source and/or binary forms; provided that if you redistribute
  23.         the Apple Software in its entirety and without modifications, you must retain
  24.         this notice and the following text and disclaimers in all such redistributions of
  25.         the Apple Software.  Neither the name, trademarks, service marks or logos of
  26.         Apple Computer, Inc. may be used to endorse or promote products derived from the
  27.         Apple Software without specific prior written permission from Apple.  Except as
  28.         expressly stated in this notice, no other rights or licenses, express or implied,
  29.         are granted by Apple herein, including but not limited to any patent rights that
  30.         may be infringed by your derivative works or by other works in which the Apple
  31.         Software may be incorporated.
  32.  
  33.         The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
  34.         WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
  35.         WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  36.         PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
  37.         COMBINATION WITH YOUR PRODUCTS.
  38.  
  39.         IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
  40.         CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  41.         GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  42.         ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
  43.         OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
  44.         (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
  45.         ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  46.  
  47.     Change History (most recent first):
  48.         Tue, Feb 8, 2000 -- created
  49. */
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57. #include "HandyWindow.h"
  58. #include "SampleUtils.h"
  59.  
  60. #include <Resources.h>
  61. #include <StdDef.h>
  62. #include <string.h>
  63. #include <Sound.h>
  64. #include <TextUtils.h>
  65. #include <Controls.h>
  66. #include <ControlDefinitions.h>
  67. #include <Script.h>
  68. #include <OSUtils.h>
  69. #include <PLStringFuncs.h>
  70.  
  71.  
  72.     /* constants used to define the image size. */
  73. #define kBoxSize 80 /* size of color swatches */
  74. #define kLineSize 2 /* pensize used to draw the boxes */
  75. #define kPatchSize (kBoxSize + 2) /* color swatch size with border */
  76. #define kColumnCount 16 /* number of columns of color swatches */
  77. #define kRowCount 16 /* number of rows of color swatches */
  78. #define kImageWidth (kPatchSize * kColumnCount) /* total width of the image */
  79. #define kImageHeight (kPatchSize * kRowCount) /* total height of the image */
  80. #define kTimerDisplayWidth 100 /* width of timer display area */
  81.  
  82. /* resource ID numbers for the STR# resource used for
  83.     storing window title strings.*/
  84. enum {
  85.     kHandyWindowStrings = 128,
  86.     kHandyWindowTitle = 1,
  87.     kHandyWindowSlowTitle = 2
  88. };
  89.  
  90.  
  91. /* some ascii codes for special keys on the US keyboard. we use these codes
  92.     in the HandyWindowKey for dispatching keydown events to the scrolling
  93.     routines.  */
  94. enum {
  95.     SOH = 1,        /* HOME KEY*/
  96.     EOT = 4,        /* END KEY*/
  97.     VT = 11,        /* PAGEUP KEY*/
  98.     FF = 12,        /* PAGEDOWN KEY*/
  99.     FS = 28,        /* LEFT ARROW KEY */
  100.     GS = 29,        /* RIGHT ARROW KEY */
  101.     RS = 30,        /* UP ARROW KEY */
  102.     US = 31        /* DOWN ARROW KEY */
  103. };
  104.  
  105.  
  106.  
  107. /* the HandyWindowRecord type is used for storing information related
  108.     to each HandyWindow.  We use these records to store references
  109.     to the scroll bars, and the window's activation state.  Also, we store
  110.     a pointer to the window in this structure.  In this sample, we use this
  111.     as the key value for finding a given window's HandyWindowRecord record. */
  112. typedef struct HandyWindowStruct HandyWindowRecord;
  113. typedef HandyWindowRecord *HandyWindowPtr;
  114. struct HandyWindowStruct {
  115.     HandyWindowPtr prev, next; /* pointers for our list of handy window records */
  116.     WindowPtr theWindow; /* a pointer to our handy window */
  117.     ControlHandle hScroll, vScroll; /* the horizontal and vertical scroll bars */
  118.     Boolean isActive; /* the window's activation state */
  119.     Boolean useSlowDrawing; /* if true, then add delays while drawing */
  120. };
  121.  
  122.  
  123.  
  124. /* gHWFirst and gHWLast are the first and last pointers in a
  125.     linked list of HandyWindowRecord records. */
  126. static HandyWindowPtr gHWFirst = NULL, gHWLast = NULL;
  127.  
  128.  
  129.  
  130.  
  131. /* ScrollRectInBlack since the background for our image is black, it would
  132.     be desirable that during scrolling operations the scrolled in area should
  133.     be drawn 'black' instead of the default white colour.  To make this happen,
  134.     se set the background colour to black before calling scroll rect.  ScrollRectInBlack
  135.     is the same as calling ScrollRect except it scrolls in a black area rather than
  136.     a white one. This helps avoid unnecessary white to black flickering during scrolling
  137.     operations. */
  138. static void ScrollRectInBlack(const Rect* r, short dh, short dv, RgnHandle updateRgn) {
  139.     RGBColor rgbSave, rgbBlack = { 0x0000, 0x0000, 0x0000 };
  140.         /* save the pen state and background colour */
  141.     GetBackColor(&rgbSave);
  142.         /* set the background colour to black */
  143.     RGBBackColor(&rgbBlack);
  144.         /* scroll the bits */
  145.     ScrollRect(r, dh, dv, updateRgn);
  146.         /* restore the background colour */
  147.     RGBBackColor(&rgbSave);
  148. }
  149.  
  150.  
  151.  
  152. /* FindHandyWindow iterates through the list of open handy windows
  153.     looking for a HandyWindowRecord containing a window pointer
  154.     matching the theWindow.  If one is found, a pointer to the
  155.     HandyWindowRecord is returned.  If there is no HandyWindowRecord
  156.     record for the window in the list of open handy windows, then
  157.     NULL is returned. */
  158. static HandyWindowPtr FindHandyWindow(WindowPtr theWindow) {
  159.     HandyWindowPtr rover;
  160.     for (rover = gHWFirst; rover != NULL; rover = rover->next)
  161.         if (rover->theWindow == theWindow)
  162.             return rover;
  163.     return NULL;
  164. }
  165.  
  166.  
  167.  
  168. /* NewHandyWindowRec allocates a new HandyWindowRecord record,
  169.     adds it to the list of open handy windows, and returns a pointer
  170.     to it.  If there is not enough memory to complete the allocation
  171.     request, this routine will return NULL. */
  172. static HandyWindowPtr NewHandyWindowRec(WindowPtr theWindow) {
  173.     HandyWindowPtr local;
  174.     local = (HandyWindowPtr) NewPtr(sizeof(HandyWindowRecord));
  175.     if (local == NULL)
  176.         return NULL;
  177.     else {
  178.         local->theWindow = theWindow;
  179.         local->prev = local->next = NULL;
  180.         if (gHWFirst == NULL) {
  181.             gHWFirst = gHWLast = local;
  182.         } else {
  183.             local->next = gHWFirst;
  184.             gHWFirst->prev = local;
  185.             gHWFirst = local;
  186.         }
  187.     }
  188.     return local;
  189. }
  190.  
  191.  
  192.  
  193. /* DisposeHandyWindowRec removes the HandyWindowRecord
  194.     from the linked list of open handy windows and deallocates
  195.     the storage it occupies. */
  196. static void DisposeHandyWindowRec(HandyWindowPtr hwRec) {
  197.     if (hwRec->next != NULL)
  198.         hwRec->next->prev = hwRec->prev;
  199.     else gHWLast = hwRec->prev;
  200.     if (hwRec->prev != NULL)
  201.         hwRec->prev->next = hwRec->next;
  202.     else gHWFirst = hwRec->next;
  203.     DisposePtr((Ptr) hwRec);
  204. }
  205.  
  206.  
  207.  
  208. /* DrawTimer draws the time tickcount in the bottom left corner of the window.
  209.     This little timer display allows you to monitor redraw times during
  210.     scrolling and update operations.  As you will notice, the strategy of 
  211.     only redrawing squares that will actually appear on the screen greatly
  212.     reduces the amount of processor time spent in the drawing routine during
  213.     scrolling  and update operations.
  214.     
  215.     To draw the entire image contains 256 squares that would require
  216.     a total of 256 ticks (4:16 Seconds) to draw when slow drawing
  217.     is turned on.  As you will notice, because of the 'draw only what needs
  218.     to be drawn strategy', timings are much than 4:16 Seconds.  */
  219. static void DrawTimer(CGrafPtr wPort, HandyWindowPtr handp, unsigned long tickcount) {
  220.     Rect windowBounds, timerRect;
  221.     RgnHandle clipsave;
  222.     FontInfo fin;
  223.     unsigned long seconds, sixtieths;
  224.     Str255 title, temp;
  225.     
  226.         /* set up for drawing */
  227.     GetClip((clipsave = NewRgn()));
  228.     SetPort(wPort);
  229.     UseThemeFont(kThemeSmallSystemFont, smSystemScript);
  230.     GetFontInfo(&fin);
  231.     GetPortBounds( wPort, &windowBounds);
  232.     SetRect( &timerRect, windowBounds.left, windowBounds.bottom-15, windowBounds.left+kTimerDisplayWidth, windowBounds.bottom+1);
  233.     timerRect.top += 1;
  234.         /* set the clip region */
  235.     ClipRect(&timerRect);
  236.     EraseRect(&timerRect);
  237.         /* calculate the string to display */
  238.     seconds = tickcount/60;
  239.     sixtieths = tickcount%60;
  240.     NumToString(seconds, title);
  241.     PLstrcat(title, "\p:");
  242.     NumToString(sixtieths, temp);
  243.     if (temp[0] == 1) PLstrcat(title, "\p0");
  244.     PLstrcat(title, temp);
  245.     PLstrcat(title, "\p Seconds");
  246.         /* display the string, centered. */
  247.     MoveTo((timerRect.right + timerRect.left - StringWidth(title)) / 2, (timerRect.bottom + timerRect.top - (fin.ascent + fin.descent))/2 + fin.ascent);
  248.     DrawString(title);
  249.         /* if we're not active, gray it out. */
  250.     if ( ! handp->isActive)
  251.         GrayOutBox(&timerRect);
  252.         /* restore and return. */
  253.     SetClip(clipsave);
  254.     DisposeRgn(clipsave);
  255. }
  256.  
  257.  
  258.  
  259. /* DrawHandyWindowImage is called to re-draw the contents of the window.  To optimize
  260.     drawing performance this routine limits the drawing routines it calls to only those
  261.     ones that will have a visual result appearing on the screen.  To do this, it calculates
  262.     the intersection of the grafport's visRgn, clipRgn, and the *bounds parameter and
  263.     tests to see if what it is about to draw resides in this region before performing
  264.     the actual drawing operations. Since the scrolling routines set the clip region to
  265.     the region returned by ScrollRect, this improves scrolling performance dramatically
  266.     by limiting the drawing operation to only the part of the image scrolled into view.*/
  267. static void DrawHandyWindowImage(CGrafPtr wPort, Rect *bounds, HandyWindowPtr handp) {
  268.     RgnHandle clipsave, temp, exposedBits;
  269.     short x, y, index, hposition, vposition;
  270.     Rect box, steps, nameplate;
  271.     RGBColor theColor, savedColor;
  272.     RGBColor rgbWhite = { 0xFFFF, 0xFFFF, 0xFFFF }, rgbBlack = { 0x0000, 0x0000, 0x0000 };
  273.     PenState ps;
  274.     Str255 titleStr, tempStr;
  275.     FontInfo fin;
  276.     CTabHandle clut;
  277.     Pattern blackPen;
  278.     unsigned long startTicks, stopTicks;
  279.         /* start the timer */
  280.     startTicks = TickCount();
  281.         /* set up locals */
  282.     hposition = GetControlValue(handp->hScroll);
  283.     vposition = GetControlValue(handp->vScroll);
  284.     index = 0;
  285.     temp = NewRgn();
  286.     clipsave = NewRgn();
  287.     exposedBits = NewRgn();
  288.     clut = GetCTable(72);
  289.         /* calculate content region */
  290.     SetPort(wPort);
  291.     UseThemeFont(kThemeSystemFont, smSystemScript);
  292.     GetFontInfo(&fin);
  293.     GetForeColor(&savedColor);
  294.     SetOrigin(0, 0);
  295.     GetClip(clipsave);
  296.         /* calculate the region of the content that needs to
  297.         be redrawn.  Here, this is the intersection of the content
  298.         area, the current clipping region, and the window's visRgn. */
  299.     RectRgn(exposedBits, bounds);
  300.         /* intersect with the clip region */
  301.     SectRgn(clipsave, exposedBits, exposedBits);
  302.         /* intersect with the visible region */
  303.     GetPortVisibleRegion(wPort, temp);
  304.     SectRgn(temp, exposedBits, exposedBits);
  305.         /* only draw, if there's actually something to draw... */
  306.     if ( ! EmptyRgn(exposedBits) ) {
  307.             /* offset the region to it's location in the contents.
  308.             We do this explicitly because although SetOrigin will move
  309.             the portRect and visRgn, it will not move the clipRgn. */
  310.         OffsetRgn(exposedBits, hposition, vposition);
  311.             /* set the origin and clipping region */
  312.         SetOrigin(hposition, vposition);
  313.         SetClip(exposedBits);
  314.             /* set up for drawing */
  315.         GetPenState(&ps);
  316.         PenSize(kLineSize, kLineSize);
  317.         PenMode(patCopy);
  318.         PenPat(GetQDGlobalsBlack(&blackPen));
  319.         RGBForeColor(&rgbBlack);
  320.         RGBBackColor(&rgbWhite);
  321.             /* erase the background *black* */
  322.         PaintRgn(exposedBits);
  323.             /* iterate through rows and columns */
  324.         for (y=0; y<kColumnCount; y++)
  325.             for (x=0; x<kRowCount; x++, index++) {
  326.                     /* calculate the location for this color swatch */ 
  327.                 SetRect(&box, 0, 0, kBoxSize, kBoxSize);
  328.                 OffsetRect(&box, x*kPatchSize + 1, y*kPatchSize + 1);
  329.                     
  330.                     /* only draw this item if the drawing operation will have
  331.                     some noticable effect on the screen.  Overall, this will save
  332.                     some time as we're not doing any of the following drawing
  333.                     or calculation operations. */
  334.                 RectRgn(temp, &box);
  335.                 SectRgn(exposedBits, temp, temp);
  336.                 if ( EmptyRgn(temp) )
  337.                     continue;
  338.                     
  339.                     /* set the colour */
  340.                 theColor = (**clut).ctTable[ index ].rgb;
  341.                 RGBForeColor(&theColor);
  342.                     /* draw an x in the box */
  343.                 MoveTo(box.left, box.top);
  344.                 LineTo(box.right - kLineSize, box.bottom - kLineSize);
  345.                 MoveTo(box.right - kLineSize, box.top);
  346.                 LineTo(box.left, box.bottom - kLineSize);
  347.                 
  348.                 
  349.                     /* for an illustration of how drawing only the exposed
  350.                     area can affect timing, uncomment the following line. */
  351.                     
  352.                     /* the following line is used to slow down drawing
  353.                     to simulate a complex drawing task.  given that the default
  354.                     size of a window will contain 6 X 4 squares, it will
  355.                     take at the very least 24 ticks (nearly half a second)
  356.                     to redraw the entire window.  But, since during scrolling
  357.                     operations only the part of the image that needs to be
  358.                     redrawn is being drawn, this doesn't really matter. */
  359.                 if (handp->useSlowDrawing) {
  360.                     unsigned long finalTicks;
  361.                     Delay(1, &finalTicks);
  362.                 }
  363.  
  364.                     /* draw some rescinding frames */
  365.                 steps = box;
  366.                 while ( ! EmptyRect(&steps)) {
  367.                     FrameRect(&steps);
  368.                     InsetRect(&steps, kLineSize + 1, kLineSize + 1);
  369.                 }
  370.                     /* calculate the cell title */
  371.                 NumToString(x, titleStr);
  372.                 PLstrcat(titleStr, "\p, ");
  373.                 NumToString(y, tempStr);
  374.                 PLstrcat(titleStr, tempStr);
  375.                     /* calculate a box for the title */
  376.                 SetRect(&nameplate, 0, 0,
  377.                     StringWidth(titleStr) + kLineSize*6,
  378.                     fin.ascent + fin.descent + kLineSize*2);
  379.                     /* center it in the color swatch */
  380.                 OffsetRect(&nameplate,
  381.                     (box.right + box.left - nameplate.right) / 2,
  382.                     (box.bottom + box.top - nameplate.bottom) / 2);
  383.                     /* erase it and draw a frame */
  384.                 EraseRect(&nameplate);
  385.                 FrameRect(&nameplate);
  386.                     /* draw the text in black and white */
  387.                 RGBForeColor(&rgbBlack);
  388.                 MoveTo(nameplate.left + kLineSize*3, nameplate.top + fin.ascent + kLineSize);
  389.                 DrawString(titleStr);
  390.             }
  391.             
  392.             /* reset the origin and clipping region */
  393.         SetPort(wPort);
  394.         SetOrigin(0, 0);
  395.         SetClip(clipsave);
  396.     }
  397.         /* clean up */
  398.     RGBForeColor(&savedColor);
  399.     DisposeRgn(clipsave);
  400.     DisposeRgn(exposedBits);
  401.     DisposeRgn(temp);
  402.     SetPenState(&ps);
  403.     DisposeCTable(clut);
  404.         /* stop the timer */
  405.     stopTicks = TickCount();
  406.     DrawTimer(wPort, handp, stopTicks - startTicks);
  407. }
  408.  
  409.  
  410.  
  411. /* IsHandyWindow returns true if the window pointer
  412.     in the HandyWindow parameter is not NULL and
  413.     points to the about box. */
  414. Boolean IsHandyWindow(WindowPtr theWindow) {
  415.     return (FindHandyWindow(theWindow) != NULL);
  416. }
  417.  
  418.  
  419.  
  420. /* GetHandyWindowGrowLimits sets the sizerect rectangle parameter
  421.     to values appropriate for passing to the GrowWindow routine. */
  422. OSErr GetHandyWindowGrowLimits(WindowPtr theWindow, Rect *sizerect) {
  423.     HandyWindowPtr handp;
  424.         /* get our window globals */
  425.     handp = FindHandyWindow(theWindow);
  426.     if (handp == NULL) return paramErr;
  427.     SetRect(sizerect, 128, 64, kImageWidth+15, kImageWidth+15);
  428.     return noErr;
  429. }
  430.  
  431.  
  432.  
  433. /* HandyWindowSizeChanged should be called whenever the size of a window
  434.     created by OpenHandyWindow has been changed by either a call to
  435.     ZoomWindow or SizeWindow. */
  436. OSErr HandyWindowSizeChanged(WindowPtr theWindow) {
  437.     HandyWindowPtr handp;
  438.     Rect wRect, hsRect, vsRect, contentRect, timerRect;
  439.     CGrafPtr wPort; 
  440.     short hmax, vmax;
  441.     RgnHandle invalidRegion;
  442.     
  443.         /* get our window globals */
  444.     handp = FindHandyWindow(theWindow);
  445.     if (handp == NULL) return paramErr;
  446.         /* set up locals */
  447.     invalidRegion = NewRgn();
  448.     SetPort((wPort = GetWindowPort(theWindow)));
  449.     GetPortBounds( wPort, &wRect);
  450.     contentRect = wRect;
  451.     contentRect.right -= 15;
  452.     contentRect.bottom -= 15;
  453.         /* accumulate the old scroll bar and timer rectangles into the update region */
  454.     RgnUnionRect(invalidRegion, GetControlBounds(handp->hScroll, &hsRect));
  455.     SetRect( &timerRect, 0, hsRect.top, kTimerDisplayWidth, hsRect.bottom);
  456.     RgnUnionRect(invalidRegion, &timerRect);
  457.     RgnUnionRect(invalidRegion, GetControlBounds(handp->vScroll, &vsRect));
  458.         /* calculate the boxes */
  459.     SetRect( &timerRect, wRect.left, wRect.bottom-15, wRect.left+kTimerDisplayWidth, wRect.bottom+1);
  460.     SetRect( &hsRect, wRect.left+kTimerDisplayWidth, wRect.bottom-15, wRect.right-14, wRect.bottom+1);
  461.     SetRect( &vsRect, wRect.right-15, wRect.top-1, wRect.right+1, wRect.bottom-14);
  462.         /* reposition the scroll bars */
  463.     SetControlBounds( handp->hScroll, &hsRect);
  464.     SetControlBounds( handp->vScroll, &vsRect);
  465.     vsRect.bottom += 15; /* include the grow box */
  466.     RgnUnionRect(invalidRegion, &timerRect);
  467.     RgnUnionRect(invalidRegion, &hsRect);
  468.     RgnUnionRect(invalidRegion, &vsRect);
  469.         /* set the horizontal scroll bar maximum and value */
  470.     hmax = kImageWidth - contentRect.right;
  471.     if (hmax < 0) hmax = 0;
  472.     if (GetControlValue(handp->hScroll) > hmax) {
  473.         SetControlValue(handp->hScroll, hmax);
  474.         RgnUnionRect(invalidRegion, &contentRect);
  475.     }
  476.     SetControlMaximum(handp->hScroll, hmax);
  477.     SetControlViewSize(handp->hScroll, kImageWidth);
  478.         /* set the vertical scroll bar maximum and value */
  479.     vmax = kImageWidth - contentRect.bottom;
  480.     if (vmax < 0) vmax = 0;
  481.     if (GetControlValue(handp->vScroll) > vmax) {
  482.         SetControlValue( handp->vScroll, vmax);
  483.         RgnUnionRect(invalidRegion, &contentRect);
  484.     }
  485.     SetControlMaximum(handp->vScroll, vmax);
  486.     SetControlViewSize(handp->vScroll, kImageWidth);
  487.         /* announce the accumulated update region */
  488.     InvalWindowRgn(theWindow, invalidRegion);
  489.     DisposeRgn(invalidRegion);
  490.     return noErr;
  491. }
  492.  
  493.  
  494.  
  495. /* OpenHandyWindow opens a handy window using the WIND resource
  496.     with the windowID ID. If successful, OpenHandyWindow returns a
  497.     pointer to the newly created window. */
  498. WindowPtr OpenHandyWindow(short windowID, Boolean drawSlow) {
  499.     Rect wRect, hsRect, vsRect;
  500.     HandyWindowPtr handp;
  501.     WindowPtr theWindow;
  502.     ControlHandle hscroll, vscroll;
  503.     Str255 title;
  504.         /* set up locals */
  505.     handp = NULL;
  506.     theWindow = NULL;
  507.     hscroll = vscroll = NULL;
  508.         /* get the window */
  509.     theWindow = GetNewCWindow(windowID, NULL, (WindowPtr)(-1));
  510.     if (theWindow == NULL) goto bail;
  511.     handp = NewHandyWindowRec(theWindow);
  512.     if (handp == NULL) goto bail;
  513.         /* set up the zoom size */
  514.     SetWindowStandardStateSize(theWindow, kImageWidth+15, kImageWidth+15);
  515.         /* create the scroll bars */
  516.     GetPortBounds(GetWindowPort(theWindow), &wRect);
  517.     SetRect(&hsRect, wRect.left, wRect.bottom-15, wRect.right-14, wRect.bottom+1);
  518.     SetRect(&vsRect, wRect.right-15, wRect.top-1, wRect.right+1, wRect.bottom-14);
  519.     hscroll = NewControl(theWindow, &hsRect, "\p", true, 0, 0, 100, kControlScrollBarLiveProc, (long) handp);
  520.     if (hscroll == NULL) goto bail;
  521.     HiliteControl(hscroll, 255);
  522.     vscroll = NewControl(theWindow, &vsRect, "\p", true, 0, 0, 100, kControlScrollBarLiveProc, (long) handp);
  523.     if (vscroll == NULL) goto bail;
  524.     HiliteControl(vscroll, 255);
  525.         /* store our data */
  526.     handp->hScroll = hscroll;
  527.     handp->vScroll = vscroll;
  528.     handp->isActive = false;
  529.     handp->useSlowDrawing = drawSlow;
  530.         /* readjust the coordinates and we're done... */
  531.     HandyWindowSizeChanged(theWindow);
  532.     GetIndString(title, kHandyWindowStrings, (handp->useSlowDrawing ? kHandyWindowSlowTitle : kHandyWindowTitle));
  533.     SetWTitle(theWindow, title);
  534.     ShowWindow(theWindow);
  535.     return theWindow;
  536. bail:
  537.     if (hscroll != NULL) DisposeControl(hscroll);
  538.     if (vscroll != NULL) DisposeControl(vscroll);
  539.     if (theWindow != NULL) DisposeWindow(theWindow);
  540.     if (handp != NULL) DisposeHandyWindowRec(handp);
  541.     return NULL;
  542. }
  543.  
  544.  
  545.  
  546. /* HandyWindowCloseWindow closes the about box window. 
  547.     this routine deallocates any structures allocated
  548.     by the OpenHandyWindow. */
  549. OSErr HandyWindowCloseWindow(WindowPtr theWindow) {
  550.     HandyWindowPtr handp;
  551.     handp = FindHandyWindow(theWindow);
  552.     if (handp == NULL) return paramErr;
  553.     DisposeControl(handp->hScroll);
  554.     DisposeControl(handp->vScroll);
  555.     DisposeWindow(handp->theWindow);
  556.     DisposeHandyWindowRec(handp);
  557.     return noErr;
  558. }
  559.  
  560.  
  561.  
  562. /* CloseAllHandyWindows closes every handy window
  563.     opened by calling OpenHandyWindow. */
  564. void CloseAllHandyWindows(void) {
  565.     while (gHWFirst != NULL) 
  566.         HandyWindowCloseWindow(gHWFirst->theWindow);
  567. }
  568.  
  569.  
  570. /* HandyWindowUpdate should be called for update events
  571.     directed at a handy window.  It calls
  572.     BeginUpdate and EndUpdate and does all of the
  573.     drawing required to refresh the handy window. */
  574. OSErr HandyWindowUpdate(WindowPtr theWindow) {
  575.     HandyWindowPtr handp;
  576.     CGrafPtr windowGp;
  577.     Rect contents, timerRect, wRect;
  578.         /* set up our variables */
  579.     handp = FindHandyWindow(theWindow);
  580.     if (handp == NULL) return paramErr;
  581.         /* set up the window */
  582.     windowGp = GetWindowPort(theWindow);
  583.     SetPort(windowGp);
  584.     GetPortBounds(windowGp, &wRect);
  585.         /* make sure the timer rectangle is part of the update region */
  586.     SetRect( &timerRect, wRect.left, wRect.bottom-15, wRect.left+kTimerDisplayWidth, wRect.bottom+1);
  587.     InvalWindowRect(theWindow, &timerRect);
  588.     contents = wRect;
  589.     contents.right -= 15;
  590.     contents.bottom -= 15;
  591.         /* set the window for drawing */
  592.     BeginUpdate(theWindow);
  593.         /* draw the controls and grow icon */
  594.     Draw1Control(handp->hScroll);
  595.     Draw1Control(handp->vScroll);
  596.     DrawGrowIcon(theWindow);
  597.         /* update the image */
  598.     DrawHandyWindowImage(windowGp, &contents, handp);
  599.         /* if the window is inactive, gray out the image */
  600.     if ( ! handp->isActive)
  601.         GrayOutBox(&contents);
  602.         /* done drawing */
  603.     EndUpdate(theWindow);
  604.     return noErr;
  605. }
  606.  
  607.  
  608.  
  609. /* HandyWindowActivate should be called for activate events
  610.     directed at a handy window. */
  611. OSErr HandyWindowActivate(WindowPtr theWindow, Boolean activate) {
  612.     HandyWindowPtr handp;
  613.         /* verify the window is a handy window, get the variables */
  614.     if ((handp = FindHandyWindow(theWindow)) == NULL) return paramErr;
  615.         /* if the activate state is changing */
  616.     if (handp->isActive != activate) {
  617.         Rect bounds;
  618.         CGrafPtr wPort;
  619.             /* set the new activation state */
  620.         handp->isActive = activate;
  621.         wPort = GetWindowPort(theWindow);
  622.             /* redraw as appropriate for new activation state */
  623.         SetPort(wPort);
  624.         GetPortBounds(wPort, &bounds);
  625.         bounds.right -= 15;
  626.         bounds.bottom -= 15;
  627.         if (handp->isActive) {
  628.                 /* if the window is active, enable scroll bars and redraw contents */
  629.             HiliteControl(handp->hScroll, 0);
  630.             HiliteControl(handp->vScroll, 0);
  631.             InvalWindowRect(theWindow, &bounds);
  632.         } else {
  633.                 /* if the window is inactive, disable the scroll bars and gray out contents */
  634.             HiliteControl(handp->hScroll, 255);
  635.             HiliteControl(handp->vScroll, 255);
  636.             GrayOutBox(&bounds);
  637.             DrawGrowIcon(theWindow);
  638.             DrawTimer(wPort, handp, 0);
  639.         }
  640.     }
  641.     return noErr;
  642. }
  643.  
  644.  
  645.  
  646. /* gPreviousScrollValue contains the last value of the scroll bar before the
  647.     most recent scroll bar tracking operation.  This value is used for tracking
  648.     previous scroll values so we can determine the distance the display needs
  649.     to be scrolled during live scrolling and indicator draggs.   It is only used
  650.     in when the click is in the kControlIndicatorPart part. */
  651. short gPreviousScrollValue = 0;
  652.  
  653.  
  654.  
  655. /* WindowScrollBarProc is the callback procedure we pass to TrackControl
  656.     during the handling of mouse clicks in scroll bars.  It is also possible
  657.     to call this routine specifying one of the part codes to obtain different
  658.     scrolling behaviors (we do this for the arrow keys in the HandyWindowKey
  659.     routine defined below). */
  660. static pascal void WindowScrollBarProc(ControlHandle theControl, short partCode) {
  661.     short prev, max, next, *delta;
  662.     short dh, dv, pageSize;
  663.     HandyWindowPtr handp;
  664.     Rect content;
  665.     RgnHandle parttodraw, clipsave;
  666.     CGrafPtr wPort;
  667.         /* set up our local variables */
  668.     handp = (HandyWindowPtr) GetControlReference(theControl);
  669.     SetPort((wPort = GetWindowPort(handp->theWindow)));
  670.     GetPortBounds(wPort, &content);
  671.     content.right -= 15;
  672.     content.bottom -= 15;
  673.          /* initialize the horizontal and the vertical delta variables.
  674.          dv and dh are used to store the vertical and horizontal distance
  675.          the display is to be scrolled. */
  676.     dh = dv = 0;
  677.         /* calculate the page size and the delta variable
  678.         we are going to be using.  The delta variable we are
  679.         changing and the page size depends on the scroll
  680.         bar we are tracking.  */
  681.     if (theControl == handp->vScroll) {
  682.         pageSize = content.bottom - content.top;
  683.         delta = &dv;
  684.     } else {
  685.         pageSize = content.right - content.left;
  686.         delta = &dh;
  687.     }
  688.         /* calculate the previous and next scroll bar
  689.         positions. */
  690.     switch (partCode) {
  691.     
  692.             /* for the up and down buttons, we scroll
  693.             sizteen pixels */
  694.         case kControlUpButtonPart:
  695.             prev = GetControlValue(theControl);
  696.             next = prev - 16;
  697.             break;
  698.         case kControlDownButtonPart:
  699.             prev = GetControlValue(theControl);
  700.             next = prev + 16;
  701.             break;
  702.             
  703.             /* for the page up and page down areas, we scroll
  704.             one page at a time (the width of the window for the
  705.             horizontal scroll bar, and the height of the window for
  706.             the vertical scroll bar. */
  707.         case kControlPageUpPart:
  708.             prev = GetControlValue(theControl);
  709.             next = prev - pageSize;
  710.             break;
  711.         case kControlPageDownPart:
  712.             prev = GetControlValue(theControl);
  713.             next = prev + pageSize;
  714.             break;
  715.             
  716.             /* kControlIndicatorPart will be passed to this routine
  717.             during live scrolling operations or when the user is tracking
  718.             the indicator part.  Here, we calculate the distance the indicator
  719.             has been moved using the gPreviousScrollValue global variable.
  720.             note, we set the gPreviousScrollValue variable to the current
  721.             scroll bar value so we can calculate the next delta the next time
  722.             we are called. */
  723.         case kControlIndicatorPart:
  724.             prev = gPreviousScrollValue;
  725.             gPreviousScrollValue = next = GetControlValue(theControl);
  726.             break;
  727.             
  728.             /* if the user moves the mouse outside of the part that was
  729.             originally clicked in, we may be called with a part code of zero.
  730.             nothing to do here...*/
  731.         default:
  732.             return;
  733.     }
  734.         /* verify that our next value is in the allowable range of value */
  735.     max = GetControlMaximum(theControl);
  736.     if (next < 0) next = 0; else if (next > max) next = max;
  737.         /* calculate the change.  If there's no change, we're done.
  738.         This is an important check as calling ScrollRect(.., 0, 0, xx)
  739.         will crash on some systems. */
  740.     *delta = prev - next;
  741.     if (*delta == 0) return;
  742.         /* set the new control bar value.  if we're tracking the indicator
  743.         next will already be the scroll value so there's no need to change
  744.         it here, that's why there's the extra check */
  745.     if (GetControlValue(theControl) != next)
  746.         SetControlValue(theControl, next);
  747.         /* save the current clipping region */
  748.     GetClip((clipsave = NewRgn()));
  749.         /* scroll the content area using our delta.  This call to
  750.         ScrollRect will set the region parttodraw to the new
  751.         'undrawn' area exposed by the operation */
  752.     ScrollRectInBlack(&content, dh, dv, (parttodraw = NewRgn()));
  753.         /* DrawHandyWindowImage will only perform drawing operations
  754.         that are visible in the current clipping region, so to tell it that it does
  755.         not have to draw the entire image, we set the clipping region to
  756.         only the part that has been erased by the scrolling operation. */
  757.     SetClip(parttodraw);
  758.         /* draw the scrolled in area */
  759.     DrawHandyWindowImage(GetWindowPort(handp->theWindow), &content, handp);
  760.         /* restore the clipping region and clean up our storage */
  761.     SetClip(clipsave);
  762.     DisposeRgn(clipsave);
  763.     DisposeRgn(parttodraw);
  764. }
  765.  
  766.  
  767.  
  768. /* HandyWindowScrollUsingHand is called to scroll the window's view when the
  769.     mouse is clicked in the window's contents.  basically, this routine redraws the
  770.     cursor as the 'grabbing hand' and then follows the mouse scrolling the contents
  771.     and adjusting the scroll bar values as appropriate. */
  772. static void HandyWindowScrollUsingHand(HandyWindowPtr handp, Point where) {
  773.     Point currentpt, lastpt, startpt;
  774.     Point start, next, last, offset;
  775.     RgnHandle clip, drawp;
  776.     Rect mypin;
  777.     Rect content;
  778.     CGrafPtr wPort;
  779.         /* set up our local variables */
  780.     SetPort((wPort = GetWindowPort(handp->theWindow)));
  781.     GetPortBounds(wPort, &content);
  782.     content.right -= 15;
  783.     content.bottom -= 15;
  784.     startpt = lastpt = where;
  785.         /* calculate the starting point */
  786.     SetPt(&start, GetControlValue(handp->hScroll), GetControlValue(handp->vScroll));
  787.     last = start;
  788.         /* create a pin rectangle.  We use this rectangle with the window manager
  789.         PinRect routine to ensure the next value we calculate will always be
  790.         within the allowable scrollable range. */
  791.     SetRect(&mypin, 0, 0, GetControlMaximum(handp->hScroll)+1, GetControlMaximum(handp->vScroll)+1);
  792.     clip = NewRgn();
  793.     drawp = NewRgn();
  794.         /* set the cursor to the grabbing hand */
  795.     SetThemeCursor(kThemeClosedHandCursor);
  796.         /* hilite the scroll bar indicators.  This provides some visual feedback indicating
  797.         the user is now scrolling using both scroll bar indicators at the same time. */
  798.     HiliteControl(handp->hScroll, kControlIndicatorPart);
  799.     HiliteControl(handp->vScroll, kControlIndicatorPart);
  800.         /* while the mouse is being held down */
  801.     while (StillDown()) {
  802.             /* only recalculate when the mouse moves */
  803.         GetMouse(¤tpt);
  804.         if ( ! EqualPt(currentpt, lastpt)) {
  805.             lastpt = currentpt;
  806.                 /* calculate the new scroll position based on cursor movement */
  807.             next = startpt;
  808.             SubPt(currentpt, &next);
  809.             AddPt(start, &next);
  810.                 /* pin the new position into the maximum allowable range */
  811.             (* (long*) &next) = PinRect(&mypin, next);
  812.                 /* calculate the delta from the last drawn position */
  813.             offset = next;
  814.             SubPt(last, &offset);
  815.                 /* only redraw and adjust scroll bar values if we
  816.                 are going to move the image.... */
  817.             if (offset.h != 0 || offset.v != 0) {
  818.                     /* set the new scrolling position */
  819.                 SetControlValue(handp->hScroll, next.h);
  820.                 SetControlValue(handp->vScroll, next.v);
  821.                 last = next;
  822.                     /* save the clipping region */
  823.                 GetClip(clip);
  824.                     /* scroll the image.  drawp will be set to the area exposed by
  825.                     the scrolling operation. */
  826.                 ScrollRectInBlack(&content, -offset.h, -offset.v, drawp);
  827.                     /* DrawHandyWindowImage will only perform drawing operations
  828.                     inside of the current clipping region.  So, to speed up drawing, we
  829.                     set the clip region to the area exposed by the scroll. */
  830.                 SetClip(drawp);
  831.                     /* redraw the empty part of the screen */
  832.                 DrawHandyWindowImage(GetWindowPort(handp->theWindow), &content, handp);
  833.                     /* restore the clip region */
  834.                 SetClip(clip);
  835.             }
  836.         }
  837.     }
  838.         /* clean up our storage */
  839.     DisposeRgn(clip);
  840.     DisposeRgn(drawp);
  841.         /* unhilite the scroll bar indicators */
  842.     HiliteControl(handp->hScroll, 0);
  843.     HiliteControl(handp->vScroll, 0);
  844.         /* set the cursor back to the open hand */
  845.     SetThemeCursor(kThemeOpenHandCursor);
  846. }
  847.  
  848.  
  849.  
  850. /* HandyWindowScrollTo can be called to scroll the image to a particular
  851.     location on screen.   This routine attempts to scroll the image so that
  852.     the location refered to by position is aligned with the top left corner of
  853.     the window.  Of course, the actual distance scrolled is pinned within
  854.     the allowable range of scroll bar values. */
  855. OSErr HandyWindowScrollTo(WindowPtr theWindow, Point position) {
  856.     HandyWindowPtr handp;
  857.     Point next, last, offset;
  858.     RgnHandle clip, drawp;
  859.     Rect mypin;
  860.     Rect content;
  861.     CGrafPtr wPort;
  862.         /* set up our local variables */
  863.     handp = FindHandyWindow(theWindow);
  864.     if (handp == NULL) return paramErr;
  865.     SetPort((wPort = GetWindowPort(handp->theWindow)));
  866.     GetPortBounds(wPort, &content);
  867.     content.right -= 15;
  868.     content.bottom -= 15;
  869.     SetRect(&mypin, 0, 0, GetControlMaximum(handp->hScroll)+1, GetControlMaximum(handp->vScroll)+1);
  870.         /* set the cursor to the grabbing hand */
  871.     SetPt(&last, GetControlValue(handp->hScroll), GetControlValue(handp->vScroll));
  872.     clip = NewRgn();
  873.     drawp = NewRgn();
  874.     next = position;
  875.     (* (long*) &next) = PinRect(&mypin, next);
  876.         /* calculate the delta from the last drawn position */
  877.     offset = next;
  878.     SubPt(last, &offset);
  879.         /* if the new drawing position has changed, scroll and redraw... */
  880.     if (offset.h != 0 || offset.v != 0) {
  881.             /* set the new scrolling position */
  882.         SetControlValue(handp->hScroll, next.h);
  883.         SetControlValue(handp->vScroll, next.v);
  884.             /* scroll the image */
  885.         GetClip(clip);
  886.         ScrollRectInBlack(&content, -offset.h, -offset.v, drawp);
  887.             /* set the clip region to the area exposed by the scroll */
  888.         SetClip(drawp);
  889.             /* redraw the empty part of the screen */
  890.         DrawHandyWindowImage(GetWindowPort(handp->theWindow), &content, handp);
  891.             /* restore the clip region */
  892.         SetClip(clip);
  893.     }
  894.     DisposeRgn(clip);
  895.     DisposeRgn(drawp);
  896.     return noErr;
  897. }
  898.  
  899.  
  900.  
  901. /* HandyWindowActivate should be called for activate events
  902.     directed at the about box window. */
  903. OSErr HandyWindowMouse(WindowPtr theWindow, Point where, short modifiers) {
  904.     HandyWindowPtr handp;
  905.     CGrafPtr wPort;
  906.     Rect content, hscroll, vscroll;
  907.     ControlHandle theControl;
  908.     
  909.         /* find the windows variables.  If there are none, then it's
  910.         not one of our windows. */
  911.     if ((handp = FindHandyWindow(theWindow)) == NULL) return paramErr;
  912.     
  913.         /* set up locals, thePort, etc... */
  914.     wPort = GetWindowPort(theWindow);
  915.     SetPort(wPort);
  916.     GetPortBounds(wPort, &content);
  917.     content.right -= 15;
  918.     content.bottom -= 15;
  919.     theControl = NULL;
  920.         /* check if its in a scroll bar.  We do it this way incase other controls
  921.         are being drawn in the window's content area.  Since they are being
  922.         drawn in a different coordinate system, when this call is made is may
  923.         be possible that they overlap. */
  924.     if (PtInRect(where, GetControlBounds(handp->hScroll, &hscroll)))
  925.         theControl = handp->hScroll;
  926.     else if (PtInRect(where, GetControlBounds(handp->vScroll, &vscroll)))
  927.         theControl = handp->vScroll;
  928.         /* if it was a scroll bar, then we handle the click as either an
  929.         indicator click or as a regular part click. */
  930.     if (theControl != NULL) {
  931.         short partCode;
  932.         static ControlActionUPP gMyActionProc = NULL;
  933.             /* allocate our action procedure pointer. */
  934.         if (gMyActionProc == NULL)
  935.             gMyActionProc = NewControlActionProc(WindowScrollBarProc);
  936.             /* find the part where the mouse was clicked. */
  937.         partCode = TestControl(theControl, where);
  938.         if (partCode == kControlIndicatorPart) {
  939.                 /* if we're dragging the indicator, then we set the cursor
  940.                 so it looks like we are grabbing the indicator. */
  941.             SetThemeCursor(kThemeClosedHandCursor);
  942.                 /* save the previous scroll value.  For live scrolling, this
  943.                 value is used inside of WindowScrollBarProc.  */
  944.             gPreviousScrollValue = GetControlValue(theControl);
  945.             TrackControl(theControl, where, gMyActionProc);
  946.                 /* if the scroll bar does not support live scrolling, then this
  947.                 is where the actual scrolling will occur. Performing the scrolling
  948.                 at this point is 'the old way' kControlIndicatorPart (inThumb) drags
  949.                 were handled.  It's not really necessary here, but it has been included
  950.                 for illustration.  Without live scrolling, we would also call TrackControl
  951.                 with a NULL action procedure parameter.  */
  952.             if (gPreviousScrollValue != GetControlValue(theControl))
  953.                 WindowScrollBarProc(theControl, kControlIndicatorPart);
  954.                 /* restore the cursor to the 'open hand' since we are 'letting go'
  955.                 of the indicator. */
  956.             SetThemeCursor(kThemeOpenHandCursor);
  957.         } else if (partCode == kControlUpButtonPart || partCode == kControlDownButtonPart
  958.         || partCode == kControlPageUpPart || kControlPageDownPart) {
  959.                 /* if it's another part, then we handle all of the scrolling in our
  960.                 tracking procedure. */
  961.             TrackControl(theControl, where, gMyActionProc);
  962.         }
  963.     } else if (PtInRect(where, &content)) {
  964.         HandyWindowScrollUsingHand(handp, where);
  965.     }
  966.     return noErr;
  967. }
  968.  
  969.  
  970.  
  971. /* HandyWindowKey is called in response to key down events.  Here, we dispatch
  972.     special keys such as the arrows, page up, page down, home, and end to
  973.     their equivalent actions using the scroll bars. */
  974. OSErr HandyWindowKey(WindowPtr theWindow, char key, short modifiers) {
  975.     HandyWindowPtr handp;
  976.     Point position;
  977.         /* find the window's variables.  if it has none, it's
  978.         not one of our windows. */
  979.     if ((handp = FindHandyWindow(theWindow)) == NULL) return paramErr;
  980.     if ( ! handp->isActive) return paramErr;
  981.         /* set up locals */
  982.     switch (key) {
  983.         case SOH:                /* HOME KEY*/
  984.             SetPt(&position, 0, 0);
  985.             HandyWindowScrollTo(theWindow, position);
  986.             break;
  987.         case EOT:                /* END KEY*/
  988.             SetPt(&position, kImageWidth, kImageHeight);
  989.             HandyWindowScrollTo(theWindow, position);
  990.             break;
  991.         case VT:                /* PAGEUP KEY*/
  992.             WindowScrollBarProc(handp->vScroll, kControlPageUpPart);
  993.             break;
  994.         case FF:                /* PAGEDOWN KEY*/
  995.             WindowScrollBarProc(handp->vScroll, kControlPageDownPart);
  996.             break;
  997.         case FS:                /* LEFT ARROW KEY */
  998.             WindowScrollBarProc(handp->hScroll, kControlUpButtonPart);
  999.             break;
  1000.         case GS:                /* RIGHT ARROW KEY */
  1001.             WindowScrollBarProc(handp->hScroll, kControlDownButtonPart);
  1002.             break;
  1003.         case RS:                /* UP ARROW KEY */
  1004.             WindowScrollBarProc(handp->vScroll, kControlUpButtonPart);
  1005.             break;
  1006.         case US:                /* DOWN ARROW KEY */
  1007.             WindowScrollBarProc(handp->vScroll, kControlDownButtonPart);
  1008.             break;
  1009.         default:
  1010.             return paramErr;
  1011.             break;
  1012.     }
  1013.     return noErr;
  1014. }
  1015.  
  1016.  
  1017. /* HandyWindowGetSlow returns the state of the handy window's drawing
  1018.     speed.  For illustration, it is possible to set the drawing speed to either
  1019.     slow or fast. */
  1020. OSErr HandyWindowGetSlow(WindowPtr theWindow, Boolean *drawnSlowly) {
  1021.     HandyWindowPtr handp;
  1022.     if ((handp = FindHandyWindow(theWindow)) == NULL) return paramErr;
  1023.     *drawnSlowly = handp->useSlowDrawing;
  1024.     return noErr;
  1025. }
  1026.  
  1027. /* HandyWindowSetSlow sets the state of the handy window's drawing
  1028.     speed and posts an update event so the contents will be re-drawn
  1029.     showing the new speed.  For illustration, it is possible to set the
  1030.     drawing speed to either slow or fast. */
  1031. OSErr HandyWindowSetSlow(WindowPtr theWindow, Boolean drawSlowly) {
  1032.     HandyWindowPtr handp;
  1033.     Rect contentRect;
  1034.     Str255 title;
  1035.     if ((handp = FindHandyWindow(theWindow)) == NULL) return paramErr;
  1036.     handp->useSlowDrawing = drawSlowly;
  1037.     GetPortBounds( GetWindowPort( theWindow), &contentRect);
  1038.     contentRect.right -= 15;
  1039.     contentRect.bottom -= 15;
  1040.     InvalWindowRect(theWindow, &contentRect);
  1041.     GetIndString(title, kHandyWindowStrings, (handp->useSlowDrawing ? kHandyWindowSlowTitle : kHandyWindowTitle));
  1042.     SetWTitle(theWindow, title);
  1043.     return noErr;
  1044. }
  1045.  
  1046.  
  1047. /* HandyWindowCursor is called when a handy window is the frontmost window and
  1048.     the HandySample application is the frontmost application.  where is a point in
  1049.     the window's coordinates, and modifiers is the state of the modifier
  1050.     keys copied from the event record.  mouseRgn is a handle to a region.  If
  1051.     HandyWindowCursor sets the cursor, then it will also set this region to
  1052.     the region where it is appropriate for the cursor to remain as it has been
  1053.     set (in global coordinates).  this region is appropriate for passing to WaitNextEvent
  1054.     in the mouse region parameter. */
  1055. Boolean HandyWindowCursor(WindowPtr theWindow, Point where, short modifiers, RgnHandle mouseRgn) {
  1056.     HandyWindowPtr handp;
  1057.     CGrafPtr wPort;
  1058.     Rect contentRect;
  1059.     Point offset;
  1060.         /* find the window's variables.  if it has none, it's
  1061.         not one of our windows. */
  1062.     if ((handp = FindHandyWindow(theWindow)) == NULL) return false;
  1063.     if ( ! handp->isActive) return false;
  1064.         /* set up locals */
  1065.     SetPort((wPort = GetWindowPort( theWindow)));
  1066.         /* calculate the window's origin in global coordinates */
  1067.     SetPt(&offset, 0, 0);
  1068.     LocalToGlobal( &offset);
  1069.         /* calculate the content rectangle */
  1070.     GetPortBounds( wPort, &contentRect);
  1071.     contentRect.right -= 15;
  1072.     contentRect.bottom -= 15;
  1073.         /* find the click location */
  1074.     if (PtInRect( where, &contentRect)) {
  1075.             /* if it's in the content area, then we use the open hand. */
  1076.         RectRgn(mouseRgn, &contentRect);
  1077.         OffsetRgn(mouseRgn, offset.h, offset.v);
  1078.         SetThemeCursor(kThemeOpenHandCursor);
  1079.         return true;
  1080.         
  1081.         /* for scroll bars, we call the routine SetScrollBarCursor defined
  1082.         in SampleUtils.h.  That routine sets the cursor to a hand when it's
  1083.         over the scroll bar's indicator part.  Otherwise it sets the cursor to
  1084.         a pointing finger. */
  1085.     } else if (SetScrollBarCursor(handp->hScroll, where, mouseRgn)) {
  1086.         OffsetRgn(mouseRgn, offset.h, offset.v);
  1087.         return true;
  1088.     } else if (SetScrollBarCursor(handp->vScroll, where, mouseRgn)) {
  1089.         OffsetRgn(mouseRgn, offset.h, offset.v);
  1090.         return true;
  1091.     }
  1092.         /* if the mouse isn't in our window, then we have nothing to say about it. */
  1093.     return false;
  1094. }
  1095.  
  1096.